package org.fastsyncer.parser.util;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.fastsyncer.common.constant.MappingConstant;
import org.fastsyncer.common.entity.Mapping;

/**
 * 转换目标源数据
 * 
 * @ClassName: ConvertUtil
 * @Description: 转换目标源数据,支持前后追加、替换
 * @author: YangPei
 * @date: 2017年8月1日 上午9:29:08
 */
public class ConvertUtil {

	public static void convert(Mapping sourceMapping, Mapping targetMapping, List<Map<String, Object>> rows) {
		// 获取连接器
		Map<String, Map<String, String[]>> convertor = targetMapping.getConvertor();
		if (convertor!=null && !convertor.isEmpty()) {
			List<HashMap<String, Object>> tfileds = targetMapping.getFileds();
			List<HashMap<String, Object>> sfileds = sourceMapping.getFileds();
			
			// 定义一个数据源要转换的属性集合，用于取出对应转换的值
			Map<String,Map<String, String[]>> convertMap = new HashMap<String,Map<String, String[]>>();
			
			// 找出需要转换的数据源属性(检查目标源的中的字段是否有转换属性策略，如果不为空，说明有转换配置，则记录对应的数据源属性名称)
			int tSize = tfileds.size();
			for (int i = 0; i < tSize; i++) {
				// 目标源转换类型
				Map<String, String[]> opr = convertor.get(tfileds.get(i).get("name"));
				if(opr!=null){
					// 数据源属性名称
					String cName = (String) sfileds.get(i).get("name");
					convertMap.put(cName, opr);
					continue;
				}
			}
			
			// 如果有转换的属性
			int cSize = convertMap.size();
			if(cSize > 0){
				// 读取迁移数据 [{ID=123, NAME=张三11}, {ID=321, NAME=李四},...]
				for (Map<String, Object> map : rows) {
					
					// 遍历需要转换的属性
					for (Map.Entry<String,Map<String, String[]>> cmap : convertMap.entrySet()) {
						// 数据源属性名称
						String key = cmap.getKey();
						
						// 获取转换类型、数据源数据
						Map<String, String[]> oprs = cmap.getValue();
						String cVal = (String) map.get(key);
						
						// 更新转换后的数据
						map.put(key, convert(oprs, cVal));
					}
				}
			}
		}
	}
	
	public static void convert(Mapping targetMapping, Map<String, Object> map) {
		// 获取连接器
		Map<String, Map<String, String[]>> convertor = targetMapping.getConvertor();
		if (convertor==null || convertor.isEmpty()) {
			return;
		}
		
		for (Map.Entry<String, Object> attr : map.entrySet()) {
			// 获取ID/NAME/...
			String key = attr.getKey();
			// 获取123/张三/...
			Object value = attr.getValue();

			// 获取属性命名对应操作,[处理类型,参数]
			Map<String, String[]> convertTypes = convertor.get(key);
			if (convertTypes!=null && !convertTypes.isEmpty()) {
				map.put(key, convert(convertTypes, value));
			}
		}
	}

	/**
	 * 数据转换
	 * @Title: convert 
	 * @Description: 数据转换,根据类型转换值
	 * @param convertTypes 根据类型
	 * @param value 值
	 * @return: String 转换后的值
	 */
	private static Object convert(Map<String, String[]> convertTypes, Object value) {
		for (Map.Entry<String, String[]> opr : convertTypes.entrySet()) {
			String key = opr.getKey();
			String[] arg = opr.getValue();
			switch (key) {
			case MappingConstant.CONVERT_TYPE_PREPEND:
				// 数据转换类型_追加在前面,例如“张三”追加123 => 123张三
				value = arg[0] + value;
				break;
			case MappingConstant.CONVERT_TYPE_APPEND:
				// 数据转换类型_追加在后面,例如“张三”追加123 => 张三123
				value = value + arg[0];
				break;
			case MappingConstant.CONVERT_TYPE_REPLACE:
				// 数据转换类型_替换,例如“张?三”替换?为空字符串 => 张三
				value = value.toString().replace(arg[0], arg[1]);
				break;
			default:
				break;
			}
		}
		return value;
	}

}
